<script setup>
import { ref } from 'vue'

import Markdown from 'vue3-markdown-it'

const content = ref('如果您希望实现一个通用排序算法，可以使用 Java 中的泛型来创建一个通用的排序方法。以下是一个简单的示例，使用冒泡排序算法来对任意类型的列表进行排序。我们将使用 `Comparable` 接口来确保传入的对象可以比较。\n' +
    '\n' +
    '### 泛型通用排序示例\n' +
    '\n' +
    '```java\n' +
    'import java.util.ArrayList;\n' +
    'import java.util.List;\n' +
    '\n' +
    'public class GenericSort {\n' +
    '\n' +
    '    // 通用排序方法，使用冒泡排序算法\n' +
    '    public static <T extends Comparable<T>> void bubbleSort(List<T> list) {\n' +
    '        int n = list.size();\n' +
    '        boolean swapped;\n' +
    '\n' +
    '        for (int i = 0; i < n - 1; i++) {\n' +
    '            swapped = false;\n' +
    '            for (int j = 0; j < n - 1 - i; j++) {\n' +
    '                if (list.get(j).compareTo(list.get(j + 1)) > 0) {\n' +
    '                    // 交换\n' +
    '                    T temp = list.get(j);\n' +
    '                    list.set(j, list.get(j + 1));\n' +
    '                    list.set(j + 1, temp);\n' +
    '                    swapped = true;\n' +
    '                }\n' +
    '            }\n' +
    '            // 如果没有交换，说明已排序好\n' +
    '            if (!swapped) {\n' +
    '                break;\n' +
    '            }\n' +
    '        }\n' +
    '    }\n' +
    '\n' +
    '    public static void main(String[] args) {\n' +
    '        // 整数排序\n' +
    '        List<Integer> integers = new ArrayList<>();\n' +
    '        integers.add(5);\n' +
    '        integers.add(2);\n' +
    '        integers.add(9);\n' +
    '        integers.add(1);\n' +
    '        bubbleSort(integers);\n' +
    '        System.out.println("Sorted integers: " + integers);\n' +
    '\n' +
    '        // 字符串排序\n' +
    '        List<String> strings = new ArrayList<>();\n' +
    '        strings.add("Banana");\n' +
    '        strings.add("Apple");\n' +
    '        strings.add("Orange");\n' +
    '        bubbleSort(strings);\n' +
    '        System.out.println("Sorted strings: " + strings);\n' +
    '\n' +
    '        // 自定义对象排序\n' +
    '        List<Person> people = new ArrayList<>();\n' +
    '        people.add(new Person("Alice", 30));\n' +
    '        people.add(new Person("Bob", 25));\n' +
    '        people.add(new Person("Charlie", 35));\n' +
    '\n' +
    '        // 需要实现 Comparable 接口\n' +
    '        bubbleSort(people);\n' +
    '        System.out.println("Sorted people by name: " + people);\n' +
    '    }\n' +
    '}\n' +
    '\n' +
    'class Person implements Comparable<Person> {\n' +
    '    String name;\n' +
    '    int age;\n' +
    '\n' +
    '    Person(String name, int age) {\n' +
    '        this.name = name;\n' +
    '        this.age = age;\n' +
    '    }\n' +
    '\n' +
    '    @Override\n' +
    '    public int compareTo(Person other) {\n' +
    '        return this.name.compareTo(other.name); // 按名字排序\n' +
    '    }\n' +
    '\n' +
    '    @Override\n' +
    '    public String toString() {\n' +
    '        return name + " (" + age + ")";\n' +
    '    }\n' +
    '}\n' +
    '```\n' +
    '\n' +
    '### 代码解释：\n' +
    '\n' +
    '1. **通用排序方法 `bubbleSort`**：使用泛型 `<T extends Comparable<T>>` 使得该方法可以接收任何实现了 `Comparable` 接口的对象列表。该方法使用冒泡排序算法对列表进行排序。\n' +
    '   \n' +
    '2. **整数和字符串的排序**：在 `main` 方法中，我们创建了整数和字符串的列表，并调用 `bubbleSort` 方法对它们进行排序。\n' +
    '\n' +
    '3. **自定义对象 `Person`**：`Person` 类实现了 `Comparable` 接口，重写了 `compareTo` 方法，使得可以按名字对 `Person` 对象进行排序。\n' +
    '\n' +
    '4. **输出结果**：程序将输出排序后的整数、字符串和自定义对象列表。\n' +
    '\n' +
    '### 运行结果：\n' +
    '运行代码会输出以下内容：\n' +
    '\n' +
    '```\n' +
    'Sorted integers: [1, 2, 5, 9]\n' +
    'Sorted strings: [Apple, Banana, Orange]\n' +
    'Sorted people by name: [Alice (30), Bob (25), Charlie (35)]\n' +
    '```\n' +
    '\n' +
    '这个示例展示了如何使用泛型和 `Comparable` 接口在 Java 中实现一个通用的排序算法。您可以根据需要选择不同的排序算法（如快速排序、归并排序等）来替代冒泡排序。如果您希望实现一个通用排序算法，可以使用 Java 中的泛型来创建一个通用的排序方法。以下是一个简单的示例，使用冒泡排序算法来对任意类型的列表进行排序。我们将使用 `Comparable` 接口来确保传入的对象可以比较。\n' +
    '\n' +
    '### 泛型通用排序示例\n' +
    '\n' +
    '```java\n' +
    'import java.util.ArrayList;\n' +
    'import java.util.List;\n' +
    '\n' +
    'public class GenericSort {\n' +
    '\n' +
    '    // 通用排序方法，使用冒泡排序算法\n' +
    '    public static <T extends Comparable<T>> void bubbleSort(List<T> list) {\n' +
    '        int n = list.size();\n' +
    '        boolean swapped;\n' +
    '\n' +
    '        for (int i = 0; i < n - 1; i++) {\n' +
    '            swapped = false;\n' +
    '            for (int j = 0; j < n - 1 - i; j++) {\n' +
    '                if (list.get(j).compareTo(list.get(j + 1)) > 0) {\n' +
    '                    // 交换\n' +
    '                    T temp = list.get(j);\n' +
    '                    list.set(j, list.get(j + 1));\n' +
    '                    list.set(j + 1, temp);\n' +
    '                    swapped = true;\n' +
    '                }\n' +
    '            }\n' +
    '            // 如果没有交换，说明已排序好\n' +
    '            if (!swapped) {\n' +
    '                break;\n' +
    '            }\n' +
    '        }\n' +
    '    }\n' +
    '\n' +
    '    public static void main(String[] args) {\n' +
    '        // 整数排序\n' +
    '        List<Integer> integers = new ArrayList<>();\n' +
    '        integers.add(5);\n' +
    '        integers.add(2);\n' +
    '        integers.add(9);\n' +
    '        integers.add(1);\n' +
    '        bubbleSort(integers);\n' +
    '        System.out.println("Sorted integers: " + integers);\n' +
    '\n' +
    '        // 字符串排序\n' +
    '        List<String> strings = new ArrayList<>();\n' +
    '        strings.add("Banana");\n' +
    '        strings.add("Apple");\n' +
    '        strings.add("Orange");\n' +
    '        bubbleSort(strings);\n' +
    '        System.out.println("Sorted strings: " + strings);\n' +
    '\n' +
    '        // 自定义对象排序\n' +
    '        List<Person> people = new ArrayList<>();\n' +
    '        people.add(new Person("Alice", 30));\n' +
    '        people.add(new Person("Bob", 25));\n' +
    '        people.add(new Person("Charlie", 35));\n' +
    '\n' +
    '        // 需要实现 Comparable 接口\n' +
    '        bubbleSort(people);\n' +
    '        System.out.println("Sorted people by name: " + people);\n' +
    '    }\n' +
    '}\n' +
    '\n' +
    'class Person implements Comparable<Person> {\n' +
    '    String name;\n' +
    '    int age;\n' +
    '\n' +
    '    Person(String name, int age) {\n' +
    '        this.name = name;\n' +
    '        this.age = age;\n' +
    '    }\n' +
    '\n' +
    '    @Override\n' +
    '    public int compareTo(Person other) {\n' +
    '        return this.name.compareTo(other.name); // 按名字排序\n' +
    '    }\n' +
    '\n' +
    '    @Override\n' +
    '    public String toString() {\n' +
    '        return name + " (" + age + ")";\n' +
    '    }\n' +
    '}\n' +
    '```\n' +
    '\n' +
    '### 代码解释：\n' +
    '\n' +
    '1. **通用排序方法 `bubbleSort`**：使用泛型 `<T extends Comparable<T>>` 使得该方法可以接收任何实现了 `Comparable` 接口的对象列表。该方法使用冒泡排序算法对列表进行排序。\n' +
    '   \n' +
    '2. **整数和字符串的排序**：在 `main` 方法中，我们创建了整数和字符串的列表，并调用 `bubbleSort` 方法对它们进行排序。\n' +
    '\n' +
    '3. **自定义对象 `Person`**：`Person` 类实现了 `Comparable` 接口，重写了 `compareTo` 方法，使得可以按名字对 `Person` 对象进行排序。\n' +
    '\n' +
    '4. **输出结果**：程序将输出排序后的整数、字符串和自定义对象列表。\n' +
    '\n' +
    '### 运行结果：\n' +
    '运行代码会输出以下内容：\n' +
    '\n' +
    '```\n' +
    'Sorted integers: [1, 2, 5, 9]\n' +
    'Sorted strings: [Apple, Banana, Orange]\n' +
    'Sorted people by name: [Alice (30), Bob (25), Charlie (35)]\n' +
    '```\n' +
    '\n' +
    '这个示例展示了如何使用泛型和 `Comparable` 接口在 Java 中实现一个通用的排序算法。您可以根据需要选择不同的排序算法（如快速排序、归并排序等）来替代冒泡排序。')
const mode = ref('light')
</script>

<template>
  <Markdown :source="content"  />
</template>